package com.cskaoyan.service.wx;

import com.cskaoyan.bean.cart.Cart;
import com.cskaoyan.bean.cart.CartExample;
import com.cskaoyan.bean.goods.GoodsProduct;
import com.cskaoyan.bean.promotebean.Coupon;
import com.cskaoyan.bean.promotebean.CouponUser;
import com.cskaoyan.bean.promotebean.CouponUserExample;
import com.cskaoyan.bean.userbean.Address;
import com.cskaoyan.bo.cartBo.CartCheckedBo;
import com.cskaoyan.bo.cartBo.CartDeleteBo;
import com.cskaoyan.mapper.cart.CartMapper;
import com.cskaoyan.mapper.goodsmapper.GoodsProductMapper;
import com.cskaoyan.mapper.promotemapper.CouponMapper;
import com.cskaoyan.mapper.promotemapper.CouponUserMapper;
import com.cskaoyan.mapper.usermapper.AddressMapper;
import com.cskaoyan.vo.wx.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@Service
public class CartServiceImpl implements CartService {
    @Autowired
    CartMapper cartMapper;
    @Override
    public CartListVo index(Integer userId) {
        //用来接收返回数据
        CartListVo cartListVo = new CartListVo();

        //用来处理列表信息 找出所有订单信息 并且返回所有未被删除的订单
        CartExample cartExample = new CartExample();
        cartExample.setOrderByClause("add_time" + " " + "desc");
        CartExample.Criteria criteria = cartExample.createCriteria();
        criteria.andUserIdEqualTo(userId)
                .andDeletedEqualTo(false);

        List<Cart> carts = cartMapper.selectByExample(cartExample);

        cartListVo.setCartList(carts);

        //用来处理统计
            //总数量
        CartTotalBeanVo cartTotal = new CartTotalBeanVo();
        if(carts == null){//如果订单为null，证明该userId不存在订单
            cartTotal.setCheckedGoodsCount(0);
            cartTotal.setCheckedGoodsAmount(0);
            cartTotal.setGoodsCount(0);
            cartTotal.setGoodsAmount(0);
            cartListVo.setCartTotal(cartTotal);
            return cartListVo;
        } else {
            Integer number = 0;
            BigDecimal amount = new BigDecimal(0);
            for (Cart cart : carts) {
                amount = amount.add(cart.getPrice().multiply(BigDecimal.valueOf(cart.getNumber())));
                number += cart.getNumber();
                GoodsProduct goodsProduct = goodsProductMapper.selectByPrimaryKey(cart.getProductId());
                if(goodsProduct != null && goodsProduct.getDeleted()){
                    cart.setPicUrl("http://182.92.235.201:8083/wx/storage/fetch/o1ahs7agx09aq06zk6nf.png");
                    cartMapper.updateByPrimaryKey(cart);
                }
            }
            cartTotal.setGoodsCount(number);
            cartTotal.setGoodsAmount(amount.intValue());
        }

        //未被勾选的订单
            //count
        criteria.andCheckedEqualTo(true);
        Integer goodsCountChecked = 0;
            //amount
        List<Cart> cartsNoCheck = cartMapper.selectByExample(cartExample);
        BigDecimal sum = BigDecimal.valueOf(0.0);
        if(cartsNoCheck != null){
            for (Cart cart : cartsNoCheck) {
                sum = sum.add(cart.getPrice().multiply(BigDecimal.valueOf(cart.getNumber())));
                goodsCountChecked += cart.getNumber();
            }
        }
        cartTotal.setCheckedGoodsCount(goodsCountChecked);
        cartTotal.setCheckedGoodsAmount(sum.intValue());
        cartListVo.setCartTotal(cartTotal);

        return cartListVo;
    }

    @Override
    public CartListVo checked(CartCheckedBo cartCheckedBo ,Integer userId) {
        //修改订单信息
        int isChecked = cartCheckedBo.getIsChecked();
        boolean isCheckedBool = (isChecked == 1);

        List<Integer> productIds = cartCheckedBo.getProductIds();
        Cart cart = new Cart();
        cart.setChecked(isCheckedBool);

        for (Integer productId : productIds) {
            //一个用户在表中只能存在一条关于某种商品的数据
            CartExample cartExample = new CartExample();
            CartExample.Criteria criteria = cartExample.createCriteria();
            criteria.andUserIdEqualTo(userId);
            criteria.andProductIdEqualTo(productId);
            cartMapper.updateByExampleSelective(cart,cartExample);
        }

        //修改后返回用户的的信息
        CartListVo index = index(userId);
        return index;
    }

    @Override
    public long add(Cart cart) {
        //判断当前用户购物车内是否已经存在该商品
        Integer userId = cart.getUserId();

        CartExample cartExample1 = new CartExample();
        CartExample.Criteria criteria1 = cartExample1.createCriteria();
        criteria1.andGoodsIdEqualTo(cart.getGoodsId())
                .andUserIdEqualTo(userId)
                .andDeletedEqualTo(false);

        //对添加到购物车里的数据进行进一步的更新（goodsSn,goodsName....）
        CartAndGoodsAndProductVo cgpVo = cartMapper.getCartMessagesWithSnName(cart.getGoodsId(),cart.getProductId());
        cart.setGoodsSn(cgpVo.getGoodsSn());
        cart.setGoodsName(cgpVo.getGoodsName());
        cart.setPrice(cgpVo.getPrice());
        cart.setSpecifications(cgpVo.getSpecifications());
        cart.setPicUrl(cgpVo.getPicUrl());

        if(1 == cartMapper.countByExample(cartExample1)){
            //存在则修改 修改的同时需要将数量进行相加
            Short goodsNum = cartMapper.selectGoodsNum(userId,cart.getGoodsId(),cart.getProductId());
            Short number = cart.getNumber();
            cart.setNumber((short)(number + goodsNum));
            cart.setUpdateTime(new Date());
            cartMapper.updateByExampleSelective(cart,cartExample1);
        } else {
            //不存在则新增
            // cart(null,userId,goodsId,null,null,productId,null,number,specifications,checked=true,null,addTime,updateTime,deleted=false)
            cart.setChecked(true);
            cart.setAddTime(new Date());
            cart.setUpdateTime(new Date());
            cart.setDeleted(false);
            cartMapper.insert(cart);
        }
        //返回当前购物车商品总量
        return goodsCount(userId);
    }

    @Override
    public long goodsCount(Integer userId) {
        long num = 0;
        CartExample cartExample = new CartExample();
        CartExample.Criteria criteria = cartExample.createCriteria();
        criteria.andDeletedEqualTo(false)
                .andUserIdEqualTo(userId);

        List<Cart> carts = cartMapper.selectByExample(cartExample);

        for (Cart cart : carts) {
            num += cart.getNumber();
        }
        return num;
    }

    @Override
    public int update(Cart cart) {
        GoodsProduct goodsProduct = goodsProductMapper.selectByPrimaryKey(cart.getProductId());
        if(goodsProduct != null && goodsProduct.getNumber() < cart.getNumber()){
            cart.setNumber((short) (cart.getNumber()-1));
            return goodsProduct.getNumber();
        }
        cartMapper.updateByPrimaryKeySelective(cart);
        return 0;
    }

    @Override
    public CartListVo delete(CartDeleteBo cartDeleteBo) {
        Integer userId = 1;
        Integer[] productIds = cartDeleteBo.getProductIds();
        Cart cart = new Cart();
        for (Integer productId : productIds) {
            CartExample cartExample = new CartExample();
            CartExample.Criteria criteria = cartExample.createCriteria();
            criteria.andUserIdEqualTo(userId).andProductIdEqualTo(productId);
            cart.setDeleted(true);
            cartMapper.updateByExampleSelective(cart,cartExample);
        }

        //记得修改获得用户id的方法
        CartListVo index = index(userId);
        return index;
    }

    @Override
    public long fastAdd(Cart cart) {
        //判断当前用户购物车内是否已经存在该商品
        Integer userId = cart.getUserId();

        CartExample cartExample1 = new CartExample();
        CartExample.Criteria criteria1 = cartExample1.createCriteria();
        criteria1.andGoodsIdEqualTo(cart.getGoodsId())
                .andUserIdEqualTo(userId)
                .andDeletedEqualTo(false)
                .andProductIdEqualTo(cart.getProductId());

        //获得cart对象缺少的值
        CartAndGoodsAndProductVo cgpVo = cartMapper.getCartMessagesWithSnName(cart.getGoodsId(),cart.getProductId());
        cart.setGoodsSn(cgpVo.getGoodsSn());
        cart.setGoodsName(cgpVo.getGoodsName());
        cart.setPrice(cgpVo.getPrice());
        cart.setSpecifications(cgpVo.getSpecifications());
        cart.setPicUrl(cgpVo.getPicUrl());

        if(1 == cartMapper.countByExample(cartExample1)){
            cart.setUpdateTime(new Date());
            cartMapper.updateByExampleSelective(cart,cartExample1);
        } else {
            cart.setChecked(true);
            cart.setAddTime(new Date());
            cart.setUpdateTime(new Date());
            cart.setDeleted(false);
            cartMapper.insert(cart);
        }

        long cartId = cartMapper.selectByGoodsIdAndProductId(cart.getProductId(),cart.getGoodsId(),userId);
        //这里返回的是插入或者更新对应的购物车id
        return cartId;
    }

    @Autowired
    AddressMapper addressMapper;

    @Autowired
    GoodsProductMapper goodsProductMapper;

    @Autowired
    CouponMapper couponMapper;

    @Autowired
    CouponUserMapper couponUserMapper;

    @Autowired
    WxCouponService wxCouponService;
    @Override
    public CheckOut_FlagVo checkOut(Integer cartId, Integer addressId, Integer couponId, Integer grouponRulesId, Integer userId) {
        CheckOut_FlagVo checkOutFlagVo = new CheckOut_FlagVo();
        CheckOutVo checkOutVo = new CheckOutVo();

        //可以提前设置的值
        checkOutVo.setAddressId(addressId);
        Integer length = 0;

        //这里获得运费 以及判断条件
        checkOutVo.setFreightPrice(cartMapper.selectFrightPrice()); //  查询到后 默认添加进 但是后期比较后 进行修改
        BigDecimal frightPriceJudge = cartMapper.selectFrightPriceJudge();

        //通过接收的收货地址 来获取收货地址信息
        Address address = new Address();
        if( addressId==0 ){
            address.setId(0);
            checkOutVo.setCheckedAddress(address);
        } else {
            checkOutVo.setCheckedAddress( addressMapper.selectByPrimaryKey(addressId));
        }
        checkOutVo.setAddressId(addressId);

        //直接付款 可以根据cartId 定位到当前订单
        //从购物车则需要判断所有checked的商品

        //根据cartId是否为0，来判断是从购物车结算 还是从商品页面直接付款
        BigDecimal goodsTotalPrice = new BigDecimal(0.0);

        //这里设置返回的商品总价（goodsTotalPrice）
        CheckOut_FlagVo checkOutFlagVoTmp = getTotalPriceByUserId(userId,cartId);
        if(checkOutFlagVoTmp.getMessage() != null){
            return checkOutFlagVo;
        }
        goodsTotalPrice = checkOutFlagVoTmp.getCheckOutVo().getGoodsTotalPrice();
        checkOutVo.setGoodsTotalPrice(goodsTotalPrice);
        checkOutVo.setCheckedGoodsList(checkOutFlagVoTmp.getCheckOutVo().getCheckedGoodsList());

        //这里判断是否添加运费 前面默认添加 这里判断是否需要删除
        if(goodsTotalPrice.compareTo(frightPriceJudge)>0){
            checkOutVo.setFreightPrice(BigDecimal.valueOf(0.0));
        }

        //这里默认不使用优惠卷（couponId=-1） 但会返回优惠卷个数
        //如果传入了一个指定的优惠卷ID 则不需要判断 因为这边肯定是第二次发送请求 第一次默认不使用优惠卷id
        //即便传入了一个优惠券ID，依旧要返回使用优惠券个数

        CouponUserExample couponUserExample = new CouponUserExample();
        CouponUserExample.Criteria criteria = couponUserExample.createCriteria();
        criteria.andUserIdEqualTo(userId)   //当前用户ID
                .andStatusEqualTo((short) 0)    //指定能用的
                .andDeletedEqualTo(false);  //指定未被删除的

        //获得该用户可以获得所有的优惠券个数
        List<Integer> availableCouponIds = wxCouponService.getAvailableCouponIds(userId,cartId);
//        List<CouponUser> couponUsers = couponUserMapper.selectByExample(couponUserExample);
//
//        if(couponUsers == null ){
//            checkOutVo.setAvailableCouponLength(0);
//        } else {
//            for (CouponUser couponUser : couponUsers) {
//
//                //判断当前优惠得否可以使用
//                Coupon coupon = couponMapper.selectByPrimaryKey(couponUser.getCouponId());
//                if(coupon.getDeleted() || coupon.getStatus() != 0){    //是否被删除 以及能否使用
//                    continue;
//                }
//
//                //if当前时间在 并且 可以使用 则数量加1 但是超时 则改状态
//                if(coupon.getStartTime() != null){  //有效期的优惠券
//                    long start = couponUser.getStartTime().getTime();
//                    long end = couponUser.getEndTime().getTime();
//                    long currentTime = new Date().getTime();
//                    if(start>currentTime){
//                        continue;
//                    }
//                    if(currentTime>end){
//                        //执行update 改变coupon_user status状态
//                        CouponUser couponUser1 = new CouponUser();
//                        couponUser1.setId(couponUser.getId());
//                        couponUser1.setStatus((short) 2);
//                        couponUserMapper.updateByPrimaryKeySelective(couponUser1);
//                        continue;
//                    }
//                } else {    //有效天数
//                    long timeS = System.currentTimeMillis() - couponUser.getAddTime().getTime();    //领取后的天数
//                    long timeE = coupon.getDays() * (24 * 60 * 60 * 1000);      //可使用的天数
//                    if(timeS > timeE){
//                        continue;
//                    }
//                }
//                //是否达到条件 默认是全部商品都可以使用
//                if(goodsTotalPrice.compareTo(coupon.getMin()) < 0){
//                    continue;
//                }
//                length++;
//
//            }
//        }
//
        checkOutVo.setAvailableCouponLength(availableCouponIds.size());

        if(availableCouponIds.size() != 0){
            if(couponId != -1 && couponId != 0){
                if(!availableCouponIds.contains(couponId)){
                    couponId = 0;
                } else {
                    Coupon coupon = couponMapper.selectByPrimaryKey(couponId);  //这里传入的值和另外一个接口的接口紧密链接
                    checkOutVo.setCouponPrice(coupon.getDiscount());
                    checkOutVo.setCouponId(couponId);
                }
            }
        } else {
            couponId = 0;
        }

        //这里进行价格的计算
        BigDecimal lastPrice = goodsTotalPrice.add(checkOutVo.getFreightPrice()).subtract(checkOutVo.getCouponPrice());
        checkOutVo.setActualPrice(lastPrice);
        checkOutVo.setOrderTotalPrice(lastPrice);

        checkOutFlagVo.setCheckOutVo(checkOutVo);
        return checkOutFlagVo;
    }


    public CheckOut_FlagVo getTotalPriceByUserId(Integer userId,Integer cartId){
        CheckOut_FlagVo checkOutFlagVo = new CheckOut_FlagVo(); //返回一个包含报错信息的Vo
        CheckOutVo checkOutVo = new CheckOutVo();   //这里用来储存总价 以及返回的列表
        BigDecimal goodsTotalPrice = new BigDecimal(0.0);
        if(cartId == 0){    //从购物车结算
            CartExample cartExample = new CartExample();
            CartExample.Criteria criteria1 = cartExample.createCriteria();
            criteria1.andUserIdEqualTo(userId).andCheckedEqualTo(true).andDeletedEqualTo(false);
            List<Cart> carts = cartMapper.selectByExample(cartExample);
            //这里设置返回值中的商品列表 但列表中的商品可能失效 下面会进行判断
            checkOutVo.setCheckedGoodsList(carts);
            for (Cart cart : carts) {
                //这里判断购物车里面的数量是否小于商品总数量
                    //获得商品数量
                GoodsProduct goodsProduct = goodsProductMapper.selectByPrimaryKey(cart.getProductId());
                    //判断数量 商品数量小于购物车中数量
                if(cart.getNumber() >= goodsProduct.getNumber()){
//                    checkOutFlagVo.setMessage("商品:"+cart.getGoodsName()+"仅剩"+goodsProduct.getNumber()+"个/件/条");
                    checkOutFlagVo.setMessage("商品仅剩"+goodsProduct.getNumber());
                    return checkOutFlagVo;  //这里不需要退出循环 因为直接return
                }
                    //判断当前商品是否已经被删除
                if(goodsProduct.getDeleted()){  //商品已经被删除
//                    checkOutFlagVo.setMessage(cart.getGoodsName()+":商品已被删除");  //其实可以标记下购物车中当前商品已经失效
                    checkOutFlagVo.setMessage("商品已被删除");
                    return checkOutFlagVo;
                }
                //此时商品符合条件 去计算总价
                goodsTotalPrice = goodsTotalPrice.add(cart.getPrice().multiply(BigDecimal.valueOf(cart.getNumber())));
            }
        } else {    //从商品页面进行结算
            Cart cart = cartMapper.selectByPrimaryKey(cartId);  //获得购物车中信息

            //这里设置返回值中的商品列表 但列表中的商品可能失效 下面会进行判断
            List<Cart> carts = new ArrayList<>();
            carts.add(cart);
            checkOutVo.setCheckedGoodsList(carts);

            //这里判断购物车里面的数量是否小于商品总数量
            //获得商品数量
            GoodsProduct goodsProduct = goodsProductMapper.selectByPrimaryKey(cart.getProductId());
            //判断数量 商品数量小于购物车中数量
            if(cart.getNumber() >= goodsProduct.getNumber()){
//                checkOutFlagVo.setMessage("商品:"+cart.getGoodsName()+"仅剩"+cart.getNumber()+"个/件/条");
                checkOutFlagVo.setMessage("商品仅剩"+cart.getNumber());
                return checkOutFlagVo;  //这里不需要退出循环 因为直接return
            }
            //判断当前商品是否已经被删除
            if(goodsProduct.getDeleted()){  //商品已经被删除
                checkOutFlagVo.setMessage("当前商品已被删除");  //其实可以标记下购物车中当前商品已经失效
                return checkOutFlagVo;
            }
            //此时商品符合条件 去计算总价
            goodsTotalPrice = goodsTotalPrice.add(cart.getPrice().multiply(BigDecimal.valueOf(cart.getNumber())));
        }
        checkOutVo.setGoodsTotalPrice(goodsTotalPrice);

        checkOutFlagVo.setCheckOutVo(checkOutVo);
        return checkOutFlagVo;
    }
}
